// ZipOutputStream.cs
//
// Copyright (C) 2001 Mike Krueger
// Copyright (C) 2004 John Reilly
//
// This file was translated from java, it was part of the GNU Classpath
// Copyright (C) 2001 Free Software Foundation, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
// 
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module.  An independent module is a module which is not derived from
// or based on this library.  If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so.  If you do not wish to do so, delete this
// exception statement from your version.

// HISTORY
//  22-12-2009  Z-1649  Added AES support
//  22-02-2010  Z-1648  Zero byte entries would create invalid zip files

using System;
using System.Collections;
using System.IO;
using ICSharpCode.SharpZipLib.Checksums;
using ICSharpCode.SharpZipLib.Zip.Compression;
using ICSharpCode.SharpZipLib.Zip.Compression.Streams;

namespace ICSharpCode.SharpZipLib.Zip
{
    /// <summary>
    /// This is a DeflaterOutputStream that writes the files into a zip
    /// archive one after another.  It has a special method to start a new
    /// zip entry.  The zip entries contains information about the file name
    /// size, compressed size, CRC, etc.
    /// 
    /// It includes support for Stored and Deflated entries.
    /// This class is not thread safe.
    /// <br/>
    /// <br/>Author of the original java version : Jochen Hoenicke
    /// </summary>
    /// <example> This sample shows how to create a zip file
    /// <code>
    /// using System;
    /// using System.IO;
    /// 
    /// using ICSharpCode.SharpZipLib.Core;
    /// using ICSharpCode.SharpZipLib.Zip;
    /// 
    /// class MainClass
    /// {
    ///     public static void Main(string[] args)
    ///     {
    ///         string[] filenames = Directory.GetFiles(args[0]);
    ///         byte[] buffer = new byte[4096];
    ///         
    ///         using ( ZipOutputStream s = new ZipOutputStream(File.Create(args[1])) ) {
    ///         
    ///             s.SetLevel(9); // 0 - store only to 9 - means best compression
    ///         
    ///             foreach (string file in filenames) {
    ///                 ZipEntry entry = new ZipEntry(file);
    ///                 s.PutNextEntry(entry);
    ///
    ///                 using (FileStream fs = File.OpenRead(file)) {
    ///                     StreamUtils.Copy(fs, s, buffer);
    ///                 }
    ///             }
    ///         }
    ///     }
    /// }   
    /// </code>
    /// </example>
    public class ZipOutputStream : DeflaterOutputStream
    {
        #region Constructors
        /// <summary>
        /// Creates a new Zip output stream, writing a zip archive.
        /// </summary>
        /// <param name="baseOutputStream">
        /// The output stream to which the archive contents are written.
        /// </param>
        public ZipOutputStream(Stream baseOutputStream)
            : base(baseOutputStream, new Deflater(Deflater.DEFAULT_COMPRESSION, true))
        {
        }

        /// <summary>
        /// Creates a new Zip output stream, writing a zip archive.
        /// </summary>
        /// <param name="baseOutputStream">The output stream to which the archive contents are written.</param>
        /// <param name="bufferSize">Size of the buffer to use.</param>
        public ZipOutputStream( Stream baseOutputStream, int bufferSize )
            : base(baseOutputStream, new Deflater(Deflater.DEFAULT_COMPRESSION, true), bufferSize)
        {
        }
        #endregion
        
        /// <summary>
        /// Gets a flag value of true if the central header has been added for this archive; false if it has not been added.
        /// </summary>
        /// <remarks>No further entries can be added once this has been done.</remarks>
        public bool IsFinished 
        {
            get {
                return entries == null;
            }
        }

        /// <summary>
        /// Set the zip file comment.
        /// </summary>
        /// <param name="comment">
        /// The comment text for the entire archive.
        /// </param>
        /// <exception name ="ArgumentOutOfRangeException">
        /// The converted comment is longer than 0xffff bytes.
        /// </exception>
        public void SetComment(string comment)
        {
            // TODO: Its not yet clear how to handle unicode comments here.
            byte[] commentBytes = ZipConstants.ConvertToArray(comment);
            if (commentBytes.Length > 0xffff) {
                throw new ArgumentOutOfRangeException("comment");
            }
            zipComment = commentBytes;
        }
        
        /// <summary>
        /// Sets the compression level.  The new level will be activated
        /// immediately.
        /// </summary>
        /// <param name="level">The new compression level (1 to 9).</param>
        /// <exception cref="ArgumentOutOfRangeException">
        /// Level specified is not supported.
        /// </exception>
        /// <see cref="ICSharpCode.SharpZipLib.Zip.Compression.Deflater"/>
        public void SetLevel(int level)
        {
            deflater_.SetLevel(level);
            defaultCompressionLevel = level;
        }
        
        /// <summary>
        /// Get the current deflater compression level
        /// </summary>
        /// <returns>The current compression level</returns>
        public int GetLevel()
        {
            return deflater_.GetLevel();
        }

        /// <summary>
        /// Get / set a value indicating how Zip64 Extension usage is determined when adding entries.
        /// </summary>
        /// <remarks>Older archivers may not understand Zip64 extensions.
        /// If backwards compatability is an issue be careful when adding <see cref="ZipEntry.Size">entries</see> to an archive.
        /// Setting this property to off is workable but less desirable as in those circumstances adding a file
        /// larger then 4GB will fail.</remarks>
        public UseZip64 UseZip64
        {
            get { return useZip64_; }
            set { useZip64_ = value; }
        }
        
        /// <summary>
        /// Write an unsigned short in little endian byte order.
        /// </summary>
        private void WriteLeShort(int value)
        {
            unchecked {
                baseOutputStream_.WriteByte((byte)(value & 0xff));
                baseOutputStream_.WriteByte((byte)((value >> 8) & 0xff));
            }
        }
        
        /// <summary>
        /// Write an int in little endian byte order.
        /// </summary>
        private void WriteLeInt(int value)
        {
            unchecked {
                WriteLeShort(value);
                WriteLeShort(value >> 16);
            }
        }
        
        /// <summary>
        /// Write an int in little endian byte order.
        /// </summary>
        private void WriteLeLong(long value)
        {
            unchecked {
                WriteLeInt((int)value);
                WriteLeInt((int)(value >> 32));
            }
        }
        
        /// <summary>
        /// Starts a new Zip entry. It automatically closes the previous
        /// entry if present.
        /// All entry elements bar name are optional, but must be correct if present.
        /// If the compression method is stored and the output is not patchable
        /// the compression for that entry is automatically changed to deflate level 0
        /// </summary>
        /// <param name="entry">
        /// the entry.
        /// </param>
        /// <exception cref="System.ArgumentNullException">
        /// if entry passed is null.
        /// </exception>
        /// <exception cref="System.IO.IOException">
        /// if an I/O error occured.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// if stream was finished
        /// </exception>
        /// <exception cref="ZipException">
        /// Too many entries in the Zip file<br/>
        /// Entry name is too long<br/>
        /// Finish has already been called<br/>
        /// </exception>
        public void PutNextEntry(ZipEntry entry)
        {
            if ( entry == null ) {
                throw new ArgumentNullException("entry");
            }

            if (entries == null) {
                throw new InvalidOperationException("ZipOutputStream was finished");
            }
            
            if (curEntry != null) {
                CloseEntry();
            }

            if (entries.Count == int.MaxValue) {
                throw new ZipException("Too many entries for Zip file");
            }
            
            CompressionMethod method = entry.CompressionMethod;
            int compressionLevel = defaultCompressionLevel;
            
            // Clear flags that the library manages internally
            entry.Flags &= (int)GeneralBitFlags.UnicodeText;
            patchEntryHeader = false;

            bool headerInfoAvailable;

            // No need to compress - definitely no data.
            if (entry.Size == 0)
            {
                entry.CompressedSize = entry.Size;
                entry.Crc = 0;
                method = CompressionMethod.Stored;
                headerInfoAvailable = true;
            }
            else
            {
                headerInfoAvailable = (entry.Size >= 0) && entry.HasCrc;

                // Switch to deflation if storing isnt possible.
                if (method == CompressionMethod.Stored)
                {
                    if (!headerInfoAvailable)
                    {
                        if (!CanPatchEntries)
                        {
                            // Can't patch entries so storing is not possible.
                            method = CompressionMethod.Deflated;
                            compressionLevel = 0;
                        }
                    }
                    else // entry.size must be > 0
                    {
                        entry.CompressedSize = entry.Size;
                        headerInfoAvailable = entry.HasCrc;
                    }
                }
            }

            if (!headerInfoAvailable) {
                if (!CanPatchEntries) {
                    // Only way to record size and compressed size is to append a data descriptor
                    // after compressed data.

                    // Stored entries of this form have already been converted to deflating.
                    entry.Flags |= 8;
                } else {
                    patchEntryHeader = true;
                }
            }
            
            if (Password != null) {
                entry.IsCrypted = true;
                if (entry.Crc < 0) {
                    // Need to append a data descriptor as the crc isnt available for use
                    // with encryption, the date is used instead.  Setting the flag
                    // indicates this to the decompressor.
                    entry.Flags |= 8;
                }
            }

            entry.Offset = offset;
            entry.CompressionMethod = (CompressionMethod)method;
            
            curMethod = method;
            sizePatchPos = -1;
            
            if ( (useZip64_ == UseZip64.On) || ((entry.Size < 0) && (useZip64_ == UseZip64.Dynamic)) ) {
                entry.ForceZip64();
            }

            // Write the local file header
            WriteLeInt(ZipConstants.LocalHeaderSignature);
            
            WriteLeShort(entry.Version);
            WriteLeShort(entry.Flags);
            WriteLeShort((byte)entry.CompressionMethodForHeader);
            WriteLeInt((int)entry.DosTime);

            // TODO: Refactor header writing.  Its done in several places.
            if (headerInfoAvailable) {
                WriteLeInt((int)entry.Crc);
                if ( entry.LocalHeaderRequiresZip64 ) {
                    WriteLeInt(-1);
                    WriteLeInt(-1);
                }
                else {
                    WriteLeInt(entry.IsCrypted ? (int)entry.CompressedSize + ZipConstants.CryptoHeaderSize : (int)entry.CompressedSize);
                    WriteLeInt((int)entry.Size);
                }
            } else {
                if (patchEntryHeader) {
                    crcPatchPos = baseOutputStream_.Position;
                }
                WriteLeInt(0);  // Crc
                
                if ( patchEntryHeader ) {
                    sizePatchPos = baseOutputStream_.Position;
                }

                // For local header both sizes appear in Zip64 Extended Information
                if ( entry.LocalHeaderRequiresZip64 || patchEntryHeader ) {
                    WriteLeInt(-1);
                    WriteLeInt(-1);
                }
                else {
                    WriteLeInt(0);  // Compressed size
                    WriteLeInt(0);  // Uncompressed size
                }
            }

            byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
            
            if (name.Length > 0xFFFF) {
                throw new ZipException("Entry name too long.");
            }

            ZipExtraData ed = new ZipExtraData(entry.ExtraData);

            if (entry.LocalHeaderRequiresZip64) {
                ed.StartNewEntry();
                if (headerInfoAvailable) {
                    ed.AddLeLong(entry.Size);
                    ed.AddLeLong(entry.CompressedSize);
                }
                else {
                    ed.AddLeLong(-1);
                    ed.AddLeLong(-1);
                }
                ed.AddNewEntry(1);

                if ( !ed.Find(1) ) {
                    throw new ZipException("Internal error cant find extra data");
                }
                
                if ( patchEntryHeader ) {
                    sizePatchPos = ed.CurrentReadIndex;
                }
            }
            else {
                ed.Delete(1);
            }

#if !NET_1_1 && !NETCF_2_0
            if (entry.AESKeySize > 0) {
                AddExtraDataAES(entry, ed);
            }
#endif
            byte[] extra = ed.GetEntryData();

            WriteLeShort(name.Length);
            WriteLeShort(extra.Length);

            if ( name.Length > 0 ) {
                baseOutputStream_.Write(name, 0, name.Length);
            }
            
            if ( entry.LocalHeaderRequiresZip64 && patchEntryHeader ) {
                sizePatchPos += baseOutputStream_.Position;
            }

            if ( extra.Length > 0 ) {
                baseOutputStream_.Write(extra, 0, extra.Length);
            }
            
            offset += ZipConstants.LocalHeaderBaseSize + name.Length + extra.Length;
            // Fix offsetOfCentraldir for AES
            if (entry.AESKeySize > 0)
                offset += entry.AESOverheadSize;
            
            // Activate the entry.
            curEntry = entry;
            crc.Reset();
            if (method == CompressionMethod.Deflated) {
                deflater_.Reset();
                deflater_.SetLevel(compressionLevel);
            }
            size = 0;

            if (entry.IsCrypted) {
#if !NET_1_1 && !NETCF_2_0
                if (entry.AESKeySize > 0) {
                    WriteAESHeader(entry);
                } else
#endif
                {
                    if (entry.Crc < 0) {            // so testing Zip will says its ok
                        WriteEncryptionHeader(entry.DosTime << 16);
                    } else {
                        WriteEncryptionHeader(entry.Crc);
                    }
                }
            }
        }
        
        /// <summary>
        /// Closes the current entry, updating header and footer information as required
        /// </summary>
        /// <exception cref="System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="System.InvalidOperationException">
        /// No entry is active.
        /// </exception>
        public void CloseEntry()
        {
            if (curEntry == null) {
                throw new InvalidOperationException("No open entry");
            }

            long csize = size;
            
            // First finish the deflater, if appropriate
            if (curMethod == CompressionMethod.Deflated) {
                if (size >= 0) {
                    base.Finish();
                    csize = deflater_.TotalOut;
                }
                else {
                    deflater_.Reset();
                }
            }

            // Write the AES Authentication Code (a hash of the compressed and encrypted data)
            if (curEntry.AESKeySize > 0) {
                baseOutputStream_.Write(AESAuthCode, 0, 10);
            }

            if (curEntry.Size < 0) {
                curEntry.Size = size;
            } else if (curEntry.Size != size) {
                throw new ZipException("size was " + size + ", but I expected " + curEntry.Size);
            }
            
            if (curEntry.CompressedSize < 0) {
                curEntry.CompressedSize = csize;
            } else if (curEntry.CompressedSize != csize) {
                throw new ZipException("compressed size was " + csize + ", but I expected " + curEntry.CompressedSize);
            }
            
            if (curEntry.Crc < 0) {
                curEntry.Crc = crc.Value;
            } else if (curEntry.Crc != crc.Value) {
                throw new ZipException("crc was " + crc.Value + ", but I expected " + curEntry.Crc);
            }
            
            offset += csize;

            if (curEntry.IsCrypted) {
                if (curEntry.AESKeySize > 0) {
                    curEntry.CompressedSize += curEntry.AESOverheadSize;
                    
                } else {
                    curEntry.CompressedSize += ZipConstants.CryptoHeaderSize;
                }
            }
                
            // Patch the header if possible
            if (patchEntryHeader) {
                patchEntryHeader = false;

                long curPos = baseOutputStream_.Position;
                baseOutputStream_.Seek(crcPatchPos, SeekOrigin.Begin);
                WriteLeInt((int)curEntry.Crc);
                
                if ( curEntry.LocalHeaderRequiresZip64 ) {
                    
                    if ( sizePatchPos == -1 ) {
                        throw new ZipException("Entry requires zip64 but this has been turned off");
                    }
                    
                    baseOutputStream_.Seek(sizePatchPos, SeekOrigin.Begin);
                    WriteLeLong(curEntry.Size);
                    WriteLeLong(curEntry.CompressedSize);
                }
                else {
                    WriteLeInt((int)curEntry.CompressedSize);
                    WriteLeInt((int)curEntry.Size);
                }
                baseOutputStream_.Seek(curPos, SeekOrigin.Begin);
            }

            // Add data descriptor if flagged as required
            if ((curEntry.Flags & 8) != 0) {
                WriteLeInt(ZipConstants.DataDescriptorSignature);
                WriteLeInt(unchecked((int)curEntry.Crc));
                
                if ( curEntry.LocalHeaderRequiresZip64 ) {
                    WriteLeLong(curEntry.CompressedSize);
                    WriteLeLong(curEntry.Size);
                    offset += ZipConstants.Zip64DataDescriptorSize;
                }
                else {
                    WriteLeInt((int)curEntry.CompressedSize);
                    WriteLeInt((int)curEntry.Size);
                    offset += ZipConstants.DataDescriptorSize;
                }
            }
            
            entries.Add(curEntry);
            curEntry = null;
        }
        
        void WriteEncryptionHeader(long crcValue)
        {
            offset += ZipConstants.CryptoHeaderSize;
            
            InitializePassword(Password);
            
            byte[] cryptBuffer = new byte[ZipConstants.CryptoHeaderSize];
            Random rnd = new Random();
            rnd.NextBytes(cryptBuffer);
            cryptBuffer[11] = (byte)(crcValue >> 24);
            
            EncryptBlock(cryptBuffer, 0, cryptBuffer.Length);
            baseOutputStream_.Write(cryptBuffer, 0, cryptBuffer.Length);
        }

#if !NET_1_1 && !NETCF_2_0
        private static void AddExtraDataAES(ZipEntry entry, ZipExtraData extraData) {

            // Vendor Version: AE-1 IS 1. AE-2 is 2. With AE-2 no CRC is required and 0 is stored.
            const int VENDOR_VERSION = 2;
            // Vendor ID is the two ASCII characters "AE".
            const int VENDOR_ID = 0x4541; //not 6965;
            extraData.StartNewEntry();
            // Pack AES extra data field see http://www.winzip.com/aes_info.htm
            //extraData.AddLeShort(7);                          // Data size (currently 7)
            extraData.AddLeShort(VENDOR_VERSION);               // 2 = AE-2
            extraData.AddLeShort(VENDOR_ID);                    // "AE"
            extraData.AddData(entry.AESEncryptionStrength);     //  1 = 128, 2 = 192, 3 = 256
            extraData.AddLeShort((int)entry.CompressionMethod); // The actual compression method used to compress the file
            extraData.AddNewEntry(0x9901);
        }

        // Replaces WriteEncryptionHeader for AES
        //
        private void WriteAESHeader(ZipEntry entry) {
            byte[] salt;
            byte[] pwdVerifier;
            InitializeAESPassword(entry, Password, out salt, out pwdVerifier);
            // File format for AES:
            // Size (bytes)   Content
            // ------------   -------
            // Variable       Salt value
            // 2              Password verification value
            // Variable       Encrypted file data
            // 10             Authentication code
            //
            // Value in the "compressed size" fields of the local file header and the central directory entry
            // is the total size of all the items listed above. In other words, it is the total size of the
            // salt value, password verification value, encrypted data, and authentication code.
            baseOutputStream_.Write(salt, 0, salt.Length);
            baseOutputStream_.Write(pwdVerifier, 0, pwdVerifier.Length);
        }
#endif

        /// <summary>
        /// Writes the given buffer to the current entry.
        /// </summary>
        /// <param name="buffer">The buffer containing data to write.</param>
        /// <param name="offset">The offset of the first byte to write.</param>
        /// <param name="count">The number of bytes to write.</param>
        /// <exception cref="ZipException">Archive size is invalid</exception>
        /// <exception cref="System.InvalidOperationException">No entry is active.</exception>
        public override void Write(byte[] buffer, int offset, int count)
        {
            if (curEntry == null) {
                throw new InvalidOperationException("No open entry.");
            }
            
            if ( buffer == null ) {
                throw new ArgumentNullException("buffer");
            }
            
            if ( offset < 0 ) {
#if NETCF_1_0
                throw new ArgumentOutOfRangeException("offset");
#else
                throw new ArgumentOutOfRangeException("offset", "Cannot be negative");
#endif
            }

            if ( count < 0 ) {
#if NETCF_1_0
                throw new ArgumentOutOfRangeException("count");
#else
                throw new ArgumentOutOfRangeException("count", "Cannot be negative");
#endif
            }

            if ( (buffer.Length - offset) < count ) {
                throw new ArgumentException("Invalid offset/count combination");
            }
            
            crc.Update(buffer, offset, count);
            size += count;
            
            switch (curMethod) {
                case CompressionMethod.Deflated:
                    base.Write(buffer, offset, count);
                    break;
                
                case CompressionMethod.Stored:
                    if (Password != null) {
                        CopyAndEncrypt(buffer, offset, count);
                    } else {
                        baseOutputStream_.Write(buffer, offset, count);
                    }
                    break;
            }
        }
        
        void CopyAndEncrypt(byte[] buffer, int offset, int count)
        {
            const int CopyBufferSize = 4096;
            byte[] localBuffer = new byte[CopyBufferSize];
            while ( count > 0 ) {
                int bufferCount = (count < CopyBufferSize) ? count : CopyBufferSize;
                
                Array.Copy(buffer, offset, localBuffer, 0, bufferCount);
                EncryptBlock(localBuffer, 0, bufferCount);
                baseOutputStream_.Write(localBuffer, 0, bufferCount);
                count -= bufferCount;
                offset += bufferCount;
            }
        }
        
        /// <summary>
        /// Finishes the stream.  This will write the central directory at the
        /// end of the zip file and flush the stream.
        /// </summary>
        /// <remarks>
        /// This is automatically called when the stream is closed.
        /// </remarks>
        /// <exception cref="System.IO.IOException">
        /// An I/O error occurs.
        /// </exception>
        /// <exception cref="ZipException">
        /// Comment exceeds the maximum length<br/>
        /// Entry name exceeds the maximum length
        /// </exception>
        public override void Finish()
        {
            if (entries == null)  {
                return;
            }
            
            if (curEntry != null) {
                CloseEntry();
            }
            
            long numEntries = entries.Count;
            long sizeEntries = 0;
            
            foreach (ZipEntry entry in entries) {
                WriteLeInt(ZipConstants.CentralHeaderSignature); 
                WriteLeShort(ZipConstants.VersionMadeBy);
                WriteLeShort(entry.Version);
                WriteLeShort(entry.Flags);
                WriteLeShort((short)entry.CompressionMethodForHeader);
                WriteLeInt((int)entry.DosTime);
                WriteLeInt((int)entry.Crc);

                if ( entry.IsZip64Forced() || 
                    (entry.CompressedSize >= uint.MaxValue) )
                {
                    WriteLeInt(-1);
                }
                else {
                    WriteLeInt((int)entry.CompressedSize);
                }

                if ( entry.IsZip64Forced() ||
                    (entry.Size >= uint.MaxValue) )
                {
                    WriteLeInt(-1);
                }
                else {
                    WriteLeInt((int)entry.Size);
                }

                byte[] name = ZipConstants.ConvertToArray(entry.Flags, entry.Name);
                
                if (name.Length > 0xffff) {
                    throw new ZipException("Name too long.");
                }
                
                ZipExtraData ed = new ZipExtraData(entry.ExtraData);

                if ( entry.CentralHeaderRequiresZip64 ) {
                    ed.StartNewEntry();
                    if ( entry.IsZip64Forced() ||
                        (entry.Size >= 0xffffffff) )
                    {
                        ed.AddLeLong(entry.Size);
                    }

                    if ( entry.IsZip64Forced() ||
                        (entry.CompressedSize >= 0xffffffff) )
                    {
                        ed.AddLeLong(entry.CompressedSize);
                    }

                    if ( entry.Offset >= 0xffffffff )
                    {
                        ed.AddLeLong(entry.Offset);
                    }

                    ed.AddNewEntry(1);
                }
                else {
                    ed.Delete(1);
                }

#if !NET_1_1 && !NETCF_2_0
                if (entry.AESKeySize > 0) {
                    AddExtraDataAES(entry, ed);
                }
#endif
                byte[] extra = ed.GetEntryData();
                
                byte[] entryComment = 
                    (entry.Comment != null) ? 
                    ZipConstants.ConvertToArray(entry.Flags, entry.Comment) :
                    new byte[0];

                if (entryComment.Length > 0xffff) {
                    throw new ZipException("Comment too long.");
                }
                
                WriteLeShort(name.Length);
                WriteLeShort(extra.Length);
                WriteLeShort(entryComment.Length);
                WriteLeShort(0);    // disk number
                WriteLeShort(0);    // internal file attributes
                                    // external file attributes

                if (entry.ExternalFileAttributes != -1) {
                    WriteLeInt(entry.ExternalFileAttributes);
                } else {
                    if (entry.IsDirectory) {                         // mark entry as directory (from nikolam.AT.perfectinfo.com)
                        WriteLeInt(16);
                    } else {
                        WriteLeInt(0);
                    }
                }

                if ( entry.Offset >= uint.MaxValue ) {
                    WriteLeInt(-1);
                }
                else {
                    WriteLeInt((int)entry.Offset);
                }
                
                if ( name.Length > 0 ) {
                    baseOutputStream_.Write(name,    0, name.Length);
                }

                if ( extra.Length > 0 ) {
                    baseOutputStream_.Write(extra,   0, extra.Length);
                }

                if ( entryComment.Length > 0 ) {
                    baseOutputStream_.Write(entryComment, 0, entryComment.Length);
                }

                sizeEntries += ZipConstants.CentralHeaderBaseSize + name.Length + extra.Length + entryComment.Length;
            }
            
            using ( ZipHelperStream zhs = new ZipHelperStream(baseOutputStream_) ) {
                zhs.WriteEndOfCentralDirectory(numEntries, sizeEntries, offset, zipComment);
            }

            entries = null;
        }
        
        #region Instance Fields
        /// <summary>
        /// The entries for the archive.
        /// </summary>
        ArrayList entries  = new ArrayList();
        
        /// <summary>
        /// Used to track the crc of data added to entries.
        /// </summary>
        Crc32 crc = new Crc32();
        
        /// <summary>
        /// The current entry being added.
        /// </summary>
        ZipEntry  curEntry;
        
        int defaultCompressionLevel = Deflater.DEFAULT_COMPRESSION;
        
        CompressionMethod curMethod = CompressionMethod.Deflated;

        /// <summary>
        /// Used to track the size of data for an entry during writing.
        /// </summary>
        long size;
        
        /// <summary>
        /// Offset to be recorded for each entry in the central header.
        /// </summary>
        long offset;
        
        /// <summary>
        /// Comment for the entire archive recorded in central header.
        /// </summary>
        byte[] zipComment = new byte[0];
        
        /// <summary>
        /// Flag indicating that header patching is required for the current entry.
        /// </summary>
        bool patchEntryHeader;
        
        /// <summary>
        /// Position to patch crc
        /// </summary>
        long crcPatchPos = -1;
        
        /// <summary>
        /// Position to patch size.
        /// </summary>
        long sizePatchPos = -1;

        // Default is dynamic which is not backwards compatible and can cause problems
        // with XP's built in compression which cant read Zip64 archives.
        // However it does avoid the situation were a large file is added and cannot be completed correctly.
        // NOTE: Setting the size for entries before they are added is the best solution!
        UseZip64 useZip64_ = UseZip64.Dynamic;
        #endregion
    }
}
